home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / clang / lh211src.zip / MATCH.C < prev    next >
C/C++ Source or Header  |  1991-02-22  |  4KB  |  171 lines
  1. /***********************************************************
  2.     match.c -- match filenames
  3. ***********************************************************/
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <dos.h>
  7. #include <string.h>
  8. #include <farstr.h>
  9. #include <ctype.h>
  10. #include "lh.h"
  11. #include "errmes.h"
  12.  
  13. struct pat far *pbuf;
  14. static struct pat far *pnxt, far *plst;
  15.  
  16. /***************************************
  17.     initialize pattern pointers
  18. ***************************************/
  19. void initpat(void)
  20. {
  21.     pbuf = plst = e_farmalloc(sizeof(struct pat far *));
  22.     pbuf -> nxt = NULL;
  23. }
  24.  
  25. /***************************************
  26.     regist file matching pattern
  27. ***************************************/
  28. void regpat(char *pattern, char far *bdir)
  29. {
  30.     char *p;
  31.  
  32.     p = getfilename(pattern);
  33.     pnxt = e_farmalloc(strlen(pattern) + sizeof(struct pat));
  34.     pnxt -> nxt = NULL;
  35.     pnxt -> bdir = bdir;
  36.     pnxt -> cnt = 0;
  37.     far_strcpy(pnxt -> pname, pattern);
  38.     pnxt -> fname = pnxt -> pname + (p - pattern);
  39.     plst = plst -> nxt = pnxt;
  40. }
  41.  
  42. /***************************************
  43.     regist base directory
  44. ****************************************
  45.     bdir   : base directory
  46.     return : saved address
  47. ***************************************/
  48. char far *regbdir(char *bdir)
  49. {
  50.     char far *p;
  51.  
  52.     p = e_farmalloc(strlen(bdir) + 1);
  53.     far_strcpy(p, bdir);
  54.     return p;
  55. }
  56.  
  57. /***************************************
  58.     match filename to pattern
  59.     including wild cards
  60.  
  61.     pname : filename in the pattern
  62.     fname : filename given
  63. ***************************************/
  64. char *matchfname(char far *pname, char *fname)
  65. {
  66.     static char dummy[] = " ";
  67.  
  68.     for (; *pname; pname++) {
  69.         switch (*pname) {
  70.         case '+':
  71.             while ((uchar)*fname != DELIM && *fname) fname++;
  72.             break;
  73.         case '*':
  74.             while (*fname != '.' && 
  75.                    (uchar)*fname != DELIM && *fname) fname++;
  76.             break;
  77.         case '?':
  78.             if (*fname != '.' && 
  79.                 (uchar)*fname != DELIM && *fname) fname++;
  80.             break;
  81.         case '.':
  82.             if ((uchar)*fname == DELIM || *fname == '\0')
  83.                 break;
  84.         default:
  85.             if ((*pname != *fname) && 
  86.                 (flg_i || toupper(*pname) != toupper(*fname))) {
  87.                 return dummy;        /* not NUL */
  88.             }
  89.             fname++;
  90.         }
  91.     }
  92.     return fname;
  93. }
  94.  
  95. /***************************************
  96.     match pathname to pattern
  97. ****************************************
  98.     path   : pathname
  99.     return : it's base directory
  100. ***************************************/
  101. char far *matchpat(char *path)
  102. {
  103.     struct pat far *pt;
  104.     char far *p, far *r;
  105.     char *file, *q;
  106.     char c;
  107.  
  108.     file = getfilename(path);
  109.     for (pt = pbuf -> nxt; pt != NULL; pt = pt -> nxt) {
  110.         p = pt -> pname;
  111.         switch (flg_r) {
  112.         case 0:
  113.             if (pt -> fname == p && flg_p == 0) {
  114.                 q = matchfname(p, file);
  115.             } else {
  116.                 q = matchfname(p, path);
  117.             }
  118.             if (*q) q = NULL;
  119.             break;
  120.         case 1:
  121.             c = *(r = pt -> fname);
  122.             *r = '\0';
  123.             q = matchfname(p, path);
  124.             *r = c;
  125.             if (q) {
  126.                 q = matchfname(pt -> fname, file);
  127.                 if (*q) q = NULL;
  128.             }
  129.             break;
  130.         case 2:
  131.             q = matchfname(p, path);
  132.             if (*q && (uchar)*q != DELIM) q = NULL;
  133.             break;
  134.         }
  135.         if (q) {
  136.             (pt -> cnt)++;
  137.             return (pt -> bdir);
  138.         }
  139.     }
  140.     return NULL;
  141. }
  142.  
  143. /***************************************
  144.     whether pattern was used or not
  145. ****************************************
  146.     return 0 : all pattern was used
  147.            1 : some pattern not used
  148. ***************************************/
  149. int tstpat(void)
  150. {
  151.     int cnt;
  152.     struct pat far *pt;
  153.  
  154.     cnt = 0;
  155.     for (pt = pbuf -> nxt; pt != NULL; pt = pt -> nxt)
  156.         cnt += pt -> cnt;
  157.     if (cnt == 0)                        /* no file matched */
  158.         error(NOFILEERR, NULL);
  159.     cnt = 0;
  160.     for (pt = pbuf -> nxt; pt != NULL; pt = pt -> nxt) {
  161.         if (pt -> cnt == 0) {            /* if any work name was not used */
  162.             far_strcpy(work, pt -> pname);
  163.             if (cnt == 0) eprintf("\n");
  164.             cnt++;
  165.             eprintf("%s : '%s'\n", NOMATCHERR, work);
  166.             errorlevel = 1;                /* display warning */
  167.         }
  168.     }
  169.     return errorlevel;
  170. }
  171.